#!/bin/bash
#这个文件是用于压缩mp4,并强制使用的
mp4Dir=/lhwl/data/fileupload/tszyk_viewfile.36ve.com/   #唐山mp4的目录

#通用变量
dateNow=`date +%Y%m%d`
logdir='/lhwl/bin/tmp/';mkdir -p /lhwl/bin/tmp/
logfile=${logdir}/compressAndForceUseLittleMp4Filev2.${dateNow}
ffreportLog=${logdir}/ffreport.log
size=5  #按一分钟5M的标准计算码率
mp4NewTem=${logdir}/mp4NewTem/
mkdir -p ${mp4NewTem} #压缩临时目录
rm -f ${mp4NewTem}/*
standSign=700
compressExtName=_y${standSign}
endSignTargets="y y700" #扩展名数组
newCompressSizeLogFile=${logdir}/compressAndForceUseLittleMp4FileFor4.0.newCompressSizeLogFile.${dateNow}
lossFile=${logdir}/compressAndForceUseLittleMp4Filev2.lossFiles.${dateNow}
collecteCompressFileSizSign=0 #这是收集结果的开关,开启它,那么就只计算不压缩0关闭 1开启
collecteCompressFileSizLog=${logdir}/collecteCompressFileSiz.${dateNow} #统计理论压缩大小的文件
ignoreNameFile=${logdir}/ignoreNameFile.log #
linkIgnoreNameFile=${logdir}/linkIgnoreNameFile_${standSign}.log #这是此次压缩标准对应的忽略列表,如果,存在,就不检查这个软连接对应的各种文件了
LossRealFile=${logdir}/compressAndForceUseLittleMp4Filev2.LossRealFile.${dateNow} #这是软连接对应的目标文件丢失列表
systemVersion='' #默认为空,空代表是centos


#脚本的作用:让用户使用700kb/s的视频
#查找全部mp4,不包括_y.mp4
#查看这个文件是否是软连接
#  如果是软连接
#    说明,正在工作的是压缩过的文件,
#      查看压缩过的时长是否跟老文件一致
#        如果一致,就继续
#        如果不一致,就删除,重新压缩
#      查看压缩过的文件分辨率
#        如果大于700,就对压缩过的进行压缩
#          如果压缩成功,就强制使用
#          如果不成功,就不处理了
#        如果不大于700,就不处理了
#  如果不是软连接
#    说明工作的是原文件,查看源文件分辨率是否大于700
#      如果大于,就压缩源文件
#        如果压缩成功,就强制使用
#        如果压缩不成功,就不处理了
#      如果不大于,就跳过


if [[ ${systemVersion}x != ''x ]];then
  special1="-strict -2"  #这个参数适用于ubuntu
  special2='' #这个参数适用于ubuntu
else
  #special2='-ar 27000'  #这个参数使用与centos
  special2='-ar 16k' #有的centos不支持-ar 27000
fi

dubboStandSign=$(bc <<EOF
  scale = 4
  var1 = ${standSign}
  var2 = 2
  var2 * var1 
EOF
  )   #可以计算小数的大小

function findSourceFiles(){ #查找全部mp4或MP4文件,不包括_y和_y700
  echo '###################################'   >> ${logfile}
  #echo find ${mp4Dir} -name *.mp4 >> ${logfile}
  
  echo 查找全部mp4或MP4文件,不包括_y和_y700>> ${logfile}
  echo "find ${mp4Dir} -name *4|grep -Ev \"_y.mp4|_y.MP4|${compressExtName}.mp4|${compressExtName}.MP4\"" >> ${logfile}
  sourceFileList=`find ${mp4Dir} -name *4|grep -Ev "_y.mp4|_y.MP4|${compressExtName}.mp4|${compressExtName}.MP4"`
  #sourceFileListArray=(${sourceFileList// /}) #字符串转数组
  for sourceFile in `echo ${sourceFileList}`
  do
    #echo ${sourceFile} >> ${logfile}
    sourceFileListArray[${#sourceFileListArray[@]}]=${sourceFile}
  done
    
  echo 源文件共 ${#sourceFileListArray[@]} >> ${logfile}

}

function killSelf(){
  ps -ef |grep `echo $0`|grep -v grep|awk -F ' ' '{print $2}'|xargs kill -9
}

function pass(){
  echo '' >> /dev/null
}

function getBitrate(){ #获取当前码率
  rm -f ${ffreportLog}
  echo FFREPORT=file=${ffreportLog}:level=32 ffprobe -hide_banner -i ${1} >>  ${logfile}
  FFREPORT=file=${ffreportLog}:level=32 ffprobe -hide_banner  -i ${1} #  -hide_banner 隐藏编译信息 #FFREPORT=file=tmp/ffreport.log:level=32 ffprobe -hide_banner -i /lhwl/data/upload/jnzyk.36ve.com/zyk/mat_resource/j01901v0002_1.mp4
  bitrate=`grep Duration ${ffreportLog}|awk -F ' ' '{print $6}'` # Duration: 00:03:05.17, start: 0.000000, bitrate: 5252 kb/s
  
  echo 获得到的码率为 ${bitrate}  >> ${logfile}
  
  if [ ${bitrate}x == ''x ];then
    echo "获取码率失败,设置分辨率为10000"  >> ${logfile}
    echo '################' >>${logdir}/errer
    echo FFREPORT=file=tmp/ffreport.log:level=32 ffprobe -hide_banner -i ${1} >>${logdir}/errer
    #killSelf
    #continue
    #exit
    bitrate=10000
  fi
  #killSelf
  echo ${bitrate}
  return
}

function getTime(){ #获取时长
  rm -f ${ffreportLog}
  echo FFREPORT=file=${ffreportLog}:level=32 ffprobe -hide_banner -i $1 >>  ${logfile}
  FFREPORT=file=${ffreportLog}:level=32 ffprobe -hide_banner  -i $1 #  -hide_banner 隐藏编译信息 #FFREPORT=file=tmp/ffreport.log:level=3 ffprobe -hide_banner -i /lhwl/data/upload/jnzyk.36ve.com/zyk/mat_resource/j01901v0002_1.mp4
  time=`grep Duration ${ffreportLog}|awk -F ' ' '{print $2}'` # Duration: 00:03:05.17, start: 0.000000, bitrate: 5252 kb/s
  if [ ${time}x == ''x ] ;then  #如果获得的时长为空，就停止
    echo 获取时长失败 $1 >> ${logfile}
    time=0
    #exit #这种退出是无效的,因为它是在子进程中执行的,停止的是子进程
    #killSelf 
    #continue
  fi
  echo 文件时长 ${time} >>${logfile}
  #echo "文件时长秒计算方法 echo ${time}|awk -F ':' '{print \$1*3600+\$2*60+\$3}'" >>${logfile}
  timeSecond=`echo ${time}|awk -F '[:|.]' '{print $1*3600+$2*60+$3}'` #185
  #echo "文件时长秒 ${timeSecond} ">>${logfile}
  
  #printf %0.0f ${timeSecond}
  echo ${timeSecond}
  return #return不带参数时,返回上一句的返回值
}

function insertIgnoreName(){
  #$1 待插入文件名
  #文件名为 ${ignoreNameFile}
  if [[ `grep $1 ${ignoreNameFile} `x == ''x ]];then #如果搜索结果为空,那就应该插入
    echo 将忽略文件插入"忽略列表"中 cat ${ignoreNameFile} >>  ${logfile}
    echo $1 >> ${ignoreNameFile}
    #killSelf
  fi
  
}

function insertLinkIgnoreNameFile(){ #这个函数是为了查看软连接是否在本次压缩标准的忽略列表中,如果在,说明,软连接是被处理过的,不用再检查了,否则,需要检查.
  #$1 待插入文件名
  #文件名为 ${ignoreLinkNameFile}
  if [[ `grep $1 ${linkIgnoreNameFile} `x == ''x ]];then #如果搜索结果为空,那就应该插入
    echo 将忽略软连接插入"忽略列表"中 grep $1 ${linkIgnoreNameFile} >>  ${logfile}
    echo $1 >> ${linkIgnoreNameFile}
    #killSelf
  fi
  
}


function compress(){ #压缩文件 它接收的文件有可能是原文件也有可能是真实文件的源文件
  if [[ `grep $1 ${ignoreNameFile}`x != ''x ]];then #查找结果不为空,说明这个文件应该被忽略
    echo 这个文件此前被加入过忽略列表,跳过压缩 grep $1 ${ignoreNameFile} >>  ${logfile}
    #killSelf
    echo -127 #"跳过"关系到,是否强制使用压缩过的文件,所以要向下传递一个状态信息
    return
  fi

  mp4NewTemFile=${mp4NewTem}/mp4NewTemFile.mp4 #压缩临时文件
  rm -f ${mp4NewTem}/mp4NewTemFile.mp4 
  
  sourceBitrate=`getBitrate ${1}`  #获取原码率

  echo 源文件的码率 ${sourceBitrate} >>  ${logfile}
  echo 这次的标准码率 ${standSign} >>  ${logfile}
  if [[ $(echo "${dubboStandSign} <  ${sourceBitrate}"|bc) = 1 ]];then
    echo 这次的标准码率的2倍小于原文件的码率,值得压缩 >>  ${logfile}
  else
    echo 这次的标准码率的2倍不小于源文件的码率,没有压缩的意义,跳过 >>  ${logfile}
    echo -127
    return
  fi

  sourceFileSize=`ls -l ${1} | awk '{print $5/1024/1024}'` #源文件的大小
  
  newBitrate=${standSign} #新码率等于标准码率
  
  if [[ ${collecteCompressFileSizSign} -eq 0 ]];then
    echo 执行以下语句,进行压缩!!  >> ${logfile}
    #echo ffmpeg -i ${1} -vcodec h264 -b:v ${newBitrate}k  ${mp4NewTemFile} -loglevel -8  >> ${logfile}
    #ffmpeg -i ${mp4target} -vcodec h264 -b:v 700k -vf fps=fps=24 -ab 64k  -ar 27000 ${mp4NewTemFile} 
    echo ffmpeg -i ${1} ${special1} -vcodec h264 -b:v ${newBitrate}k -vf fps=fps=24 -ab 64k ${special2}  ${mp4NewTemFile} -loglevel -8  >> ${logfile}
    
    #killSelf
    echo 正在压缩，请稍等......  >> ${logfile}
    #ffmpeg -i ${1} -vcodec h264 -b:v ${newBitrate}k  ${mp4NewTemFile} -loglevel -8
    ffmpeg -i ${1} ${special1} -vcodec h264 -b:v ${newBitrate}k -vf fps=fps=24 -ab 64k  ${special2} ${mp4NewTemFile} -loglevel -8
  else
    echo 收集压缩文件大小 >> ${logfile}
    
    collecteCompressFileSize=$(echo ${sourceFileSize}*${standSign}/${sourceBitrate}|bc) #理论压缩文件大小
    echo 原始文件大小     ${sourceFileSize} >> ${logfile}
    echo 理论压缩文件大小 ${collecteCompressFileSize} >> ${logfile}
    
    echo 原始文件大小     ${sourceFileSize} >> ${collecteCompressFileSizLog}
    echo 理论压缩文件大小 ${collecteCompressFileSize} >> ${collecteCompressFileSizLog}
  fi
  
  if [[ ${?}x != '0'x ]];then
    #只要结果不是0,那么上一条内容执行失败.停止
    #echo 压缩失败: ${1} >> ${logfile}
    echo -e "\033[34;31m执行压缩失败: ${1}\033[0m" >> ${logfile}
    insertIgnoreName ${1} #压缩失败了,把这条记录插入"忽略记录文件"中,下次不处理这条数据了
    #echo 停止
    #exit
    #killSelf
    echo -127 #压缩成不成功关系到,是否强制使用压缩过的文件,所以要向下传递一个状态信息
    return
  fi
  
  if [ ! -f ${mp4NewTemFile} ];then
    #echo 压缩失败,没有新产生的压缩文件: ${1} >> ${logfile}
    echo -e "\033[34;31m压缩失败,没有新产生的压缩文件: ${1}\033[0m" >> ${logfile}
    insertIgnoreName ${1} #压缩失败了,把这条记录插入"忽略记录文件"中,下次不处理这条数据了
    #exit
    #killSelf
    echo -127 #压缩成不成功关系到,是否强制使用压缩过的文件,所以要向下传递一个状态信息
    return
  fi
  
  echo 获取源文件的时长 >> ${logfile}
  sourceFileTimeSecond=`getTime ${1}` #源文件时长
  echo 执行以下语句,获得新压缩过的文件时长 >> ${logfile}
  compressFileTimeSecond=`getTime ${mp4NewTemFile}` #新压缩过的文件时长
  
  echo 源文件时长 ${sourceFileTimeSecond}  >> ${logfile}
  echo 刚刚压缩过的文件时长 ${compressFileTimeSecond}  >> ${logfile}
  
  if [[ ${sourceFileTimeSecond} -ge $(echo ${compressFileTimeSecond}-5|bc) && ${sourceFileTimeSecond} -le $(echo ${compressFileTimeSecond}+5|bc) ]];then
    echo 老文件时长在新文件时长上下5s之间 >> ${logfile}
  else
    #echo 压缩失败: 新文件时长不等于老文件时长 ${1} >> ${logfile}
    echo -e "\033[34;31m压缩失败: 新文件时长不等于老文件时长 ${1}\033[0m" >> ${logfile}
    insertIgnoreName ${1} #压缩失败了,把这条记录插入"忽略记录文件"中,下次不处理这条数据了
    #exit
    #killSelf
    echo -127 #压缩成不成功关系到,是否强制使用压缩过的文件,所以要向下传递一个状态信息
    return
  fi

  #sourceFileSize=`ls -l ${1} | awk '{print $5/1024/1024}'` #源文件的大小
  newCompressSize=`ls -l ${mp4NewTemFile} | awk '{print $5/1024/1024}'` #真实压缩完的大小
  
  dubboNewCompressSize=$(bc <<EOF
  scale = 4
  var1 = ${newCompressSize}
  var2 = 2
  var2 * var1 
EOF
  )   #计算小数的大小
  
  echo 源文件的大小 ${sourceFileSize} >>  ${logfile}
  echo 真实压缩完的大小 ${newCompressSize} >>  ${logfile}
  if [[ $(echo "${dubboNewCompressSize} <  ${sourceFileSize}+5"|bc) = 1 ]];then
    echo 源文件的大小 ${sourceFileSize} >> ${newCompressSizeLogFile}  
    echo 真实压缩完的大小 ${newCompressSize} >> ${newCompressSizeLogFile}  
    echo 压缩完的文件比源文件小2倍 >> ${logfile}
  else
    echo 压缩完的文件太大,压缩就没有意义,压缩失败  >> ${logfile}
    insertIgnoreName ${1} #压缩失败了,把这条记录插入"忽略记录文件"中,下次不处理这条数据了
    echo -127
    return
  fi
 
  echo 压缩成功 ${1} >> ${logfile}
  
  sourceEnd=${1##*.}
  if [[ ${sourceEnd}x = sourceFilex ]];then
    str2=${1%.*}  #aaaaaaa.mp4 
    extName=${str2##*.} #mp4
    notExtName=${str2%.*} #aaaaaaa
    compressFile=${notExtName}_y${standSign}.${extName} #aaaaaaa_y700.mp4
    echo 压缩文件名为 ${compressFile} >> ${logfile}
    #killSelf
  else #aaaaaaaa.mp4
    extName=${1##*.} #mp4
    notExtName=${1%.*} #aaaaaaa
    compressFile=${notExtName}_y${standSign}.${extName} #aaaaaaa_y700.mp4
  fi
  #获得扩展名以左的内容 %表示抛弃右边的部分 #表示抛弃左边的部分
   
  echo   mv ${mp4NewTemFile}  ${compressFile} >> ${logfile}
  echo   chown www.www ${compressFile} >> ${logfile}
  mv ${mp4NewTemFile}  ${compressFile}
  chown www.www ${compressFile}

  #killSelf
  echo 0 #压缩成不成功关系到,是否强制使用压缩过的文件,所以要向下传递一个状态信息
  return
}


function forceUseCompressFile(){  #强制使用压缩后的文件
  #sourceFile=$1
  #compressFile=$2
  bakFile=${1}.sourceFile
  echo 备份文件名为: ${bakFile} >> ${logfile}
 
  if [ -f ${bakFile} ];then #
    echo 备份文件居然存在,这不正常.应该不存在才对.终止程序 >> ${logfile}
    killSelf
  fi  

  echo '备份文件不存在 于是需要重命名,做软连接 '${bakFile} >> ${logfile} #备份文件不存在，就需要 重命名 做软连接

  echo mv ${1} ${bakFile} >> ${logfile}
  mv ${1} ${bakFile}
  #mv ${1} ${bakFile} #/lhwl/data/upload/jnzyk.36ve.com/zyk/file_dir/zjk/zgctwh/j00406v0040.mp4.sourceFile

  echo ln -s ${2} ${1} >>  ${logfile}
  ln -s ${2} ${1}
  #ln -s ${2} ${1}

  echo 强制使用完后的结果是 >>  ${logfile}
  #ls -l ${2} ${1} ${bakFile} >>  ${logfile}
  #获得不带压缩标志的文件地址
  #extName=${1##*.} # mp4
  #notExtNameFilePath=`echo ${1}|sed "s/\.${extName}//g"`  #ping_deng_pian_di_liu_jiang__0
  notExtNameFilePath=`echo ${1%.*}` #tong_ming_ming_fa_.mp4.zi_jian_ji_001
  ls -l ${notExtNameFilePath}* >>  ${logfile} # ping_deng_pian_di_liu_jiang__0
  #killSelf
}

function replaceLnsTarget(){   #替换软连接的目标文件
  #realFile = $1 #软连接
  #compressFile= $2 #新目标文件
  echo rm -f $1 >>  ${logfile}
  echo ln -s $2 $1>>  ${logfile}
  rm -f $1
  ln -s $2 $1
  #killSelf
}

function compressSourceFile (){ #查看老文件是否需要压缩,如果是 就压;压完强制
  #sourceFile=$1
  #查看老文件码率
  sourceFileBitrate=`getBitrate ${1}`
  
  echo 判断老码率是否大于${standSign},也就是本次压缩的标准值 ${standSign} >> ${logfile}
  if [[ ${sourceFileBitrate} -gt ${dubboStandSign} ]];then #删除了软连接,还原了源文件,查看源文件是否需要压缩
    echo 这次的标准码率的2倍小于老文件的码率,值得压缩 >>  ${logfile}
    #echo 需要压缩 >> ${logfile}
    compressStatus=`compress ${1}`   ##########################################################################
    #这里可以加一个强制使用
      if [[ ${compressStatus}x = 0x ]];then
        echo 可以执行强制使用 >> ${logfile}

        extName=${1##*.}
        #compressFile=`echo ${1}|sed "s/\.${extName}/_y${standSign}\.${extName}/g"` #***_y.mp4
        notExtNameSourceFileName=`echo ${1%.*}` #tong_ming_ming_fa_.mp4.zi_jian_ji_001
        compressFile=${notExtNameSourceFileName}_y${standSign}.${extName} #tong_ming_ming_fa_.mp4.zi_jian_ji_001_y700.mp4
        
        forceUseCompressFile ${1} ${compressFile}
      else
        echo 原文件压缩失败 >> ${logfile}
        #echo 源文件是软连接,真实文件时长跟压缩的时长不符,删除压缩过的文件,重新压缩,再次对比时长,再次不符.压缩措施对该文件失效,已经重新使用真实文件.不再处理这个文件 >> ${logfile}
        #echo 这里需要报告一下开发,这个文件不要在发给我了.暂时这里不报告,没有id >> ${logfile}
        echo 继续下一个文件吧 >> ${logfile}
      fi
      #break
  else
    echo 老文件的分辨率 ${sourceFileBitrate} >> ${logfile}
    echo 当前执行标准为 ${standSign} >> ${logfile}
    echo 这次的标准码率的2倍不小于老文件的码率,不值得压缩,跳过 >>  ${logfile}
    insertIgnoreName ${1}
    #echo 不需要压缩 >> ${logfile}
  fi
}

function compareTime(){
echo 对比文件$1和文件$2时长是否一致 >> ${logfile}
    #获取$1和$2的时长
    aFileTime=`getTime ${1}`
    bFileTime=`getTime ${2}`
    echo a文件时长 ${aFileTime} >> ${logfile}
    echo b文件时长 ${bFileTime} >> ${logfile}
#判断a文件和b文件时长是否一样
if [[ ${aFileTime} -ge $(echo ${bFileTime}-5|bc) && ${aFileTime} -le $(echo ${bFileTime}+5|bc) ]];then
  echo a文件时长在b文件时长上下5s之间 >> ${logfile}
  echo 1
  return
else
  echo 0
  return
fi
}

#######################################################################################################################
#######################################################################################################################
findSourceFiles #查找全部mp4文件,不包括_y和_y700

for ((i=0;i<${#sourceFileListArray[@]};i++));
#for ((i=0;i<2;i++));
do
  echo "######################" `date +%Y_%m_%d_%H_%M_%S` >> ${logfile}
  #对比时长是否和源文件一致
  sourceFile=${sourceFileListArray[${i}]}
  #sourceFile='/mnt/lvm/4.0upload/xxpt/files/6/course/39d55d00-4906-3b08-843e-e1a20b0d7d49/resource/40e9714c7c1aed7741dd2980fefb090d/2-18-1 gwxyc-1 - Storyline output/story_content/video_5bTi5jRaTun_22_48_488x224.mp4'
  #sourceFile=/mnt/lvm/4.0upload/xxpt/files/6/course/-1/resource/04myww772gan_zao_guo_cheng_de_wu_liao_ping_heng_shang_.mp4
  #sourceFile=/mnt/lvm/4.0upload/xxpt/files/6/course/b4b73306-25c4-3406-bd8f-1cd2b6918570/resource/ti_gao_hun_ning_tu_kang_dong_xing_de_cuo_shi_.mp4
  
  echo 经过了${i} / ${#sourceFileListArray[@]}次循环  >> ${logfile}
  
  fileExistResult=`ls ${sourceFile}`
  #echo '进入判断文件名是否正常阶段' >> ${logfile}
  if [[ ${fileExistResult} == ${sourceFile} ]];then
    echo 该文件名正常 ${sourceFile} >> ${logfile}
    pass
  else
    echo 该文件名有问题 ${sourceFile} >> ${logfile}
    #killSelf
    pass
    continue
  fi
  
  if [[ -d ${sourceFile} ]];then #判断是不是目录
    pass
    echo 这个是目录 ll ${sourceFile}  >> ${logfile}
    continue
    #killSelf
  else
    pass
  fi
  
  if [[ -f ${sourceFile} ]];then #判断文件是不是无效的软连接
    pass
  else
    echo 这个软连接失效了 ll ${sourceFile}  >> ${logfile}
    echo ll ${sourceFile}  >> ${LossRealFile}
    if [[ -f ${sourceFile}.sourceFile ]];then
      rm -f ${sourceFile}
      mv ${sourceFile}.sourceFile ${sourceFile}
    fi
    #killSelf
    #continue
  fi
  
  
  #continue
  #echo 源文件是 ${sourceFile}  >> ${logfile}
  #这个源文件有可能是软连接,也有肯能是真实文件
  if [[ -L ${sourceFile} ]];then

    if [[ `grep ${sourceFile} ${linkIgnoreNameFile}`x != ''x ]];then #查找结果不为空,说明这个文件应该被忽略
      echo 这个文件此前被加入过忽略列表,跳过检查 grep ${sourceFile} ${linkIgnoreNameFile} >>  ${logfile}
      #killSelf
      continue
    fi
    
    #echo 源文件是软连接 跳过 ${sourceFile}   >> ${logfile}
    #continue 
    
    realFile=`realpath ${sourceFile}` #查找真实文件
    
    if [[ -f ${realFile} ]];then
        pass
    else
        echo 源文件不存在 ${sourceFile}   >> ${logfile}
        killSelf
    fi
    
    echo 真实文件是,这是一个压缩文件 ${realFile}  >> ${logfile}
    
    realFileTime=`getTime ${realFile}`
    echo 真实文件的时长是 ${realFileTime} >> ${logfile}
    
    #realFile="ping_deng_pian_di_liu_jiang__0_y700.mp4"
    
    #获取realFile的realSourceFile
      extName=${realFile##*.} # mp4 
      
      #notExtNameFileName=`echo ${realFile}|sed "s/\.${extName}//g"` #ping_deng_pian_di_liu_jiang__0_y700
      notExtNameFileName=`echo ${realFile%.*}` # 这种写法表示截取右边第一个点之前的部分;.* 表示抛弃右边的部分;*.表示抛弃左边的部分
      #tong_ming_ming_fa_.mp4.zi_jian_ji_001_y

      echo 不包含扩展名的真实文件名是 ${notExtNameFileName} >> ${logfile}
      #查看它是否是_y或者_y700结尾的 

      endSign=`echo ${notExtNameFileName##*_}` #y y700 这是真实文件的结尾部分
      
      #killSelf
      realSourceFile='' #接下来获取真实文件的源文件
      for endSignTarget in ${endSignTargets}; #y y700
      do
        if [ ${endSign}x = ${endSignTarget}x ];then
          #获得不带扩展名的真实源文件
          #notExtNameSourceFileName=`echo ${realFile}|sed "s/_${endSign}.${extName}//g"` #ping_deng_pian_di_liu_jiang__0
          notExtNameSourceFileName=`echo ${sourceFile%.*}` #tong_ming_ming_fa_.mp4.zi_jian_ji_001
          realSourceFileName=${notExtNameSourceFileName}.${extName}.sourceFile
          # 去掉压缩标志的那部分+.真实文件的扩展名+.sourceFile  ping_deng_pian_di_liu_jiang__0.mp4.sourceFile
          echo endSign ${endSign} >> ${logfile}
          echo 真实文件的源文件名为 ${realSourceFileName} >> ${logfile} #ping_deng_pian_di_liu_jiang__0.mp4
          #定义完了真实文件的源文件,看看这个源文件是否存在
          if [ -f ${realSourceFileName} ];then #如果存在,****
            realSourceFile=${realSourceFileName}
            echo 真实文件的源文件 真的存在 ${realSourceFile} >> ${logfile}
            echo 对比真实文件的源文件和真实文件的时长是否一致 >> ${logfile}
                #获取realFile的realSourceFile的时长
                realSourceFileTime=`getTime ${realSourceFile}`
                  echo 真实文件时长 ${realFileTime} >> ${logfile}
                  echo 真实文件的源文件时长 ${realSourceFileTime} >> ${logfile}
            #判断真实文件和真实源文件时长是否一样
            if [[ ${realFileTime} -ge $(echo ${realSourceFileTime}-5|bc) && ${realFileTime} -le $(echo ${realSourceFileTime}+5|bc) ]];then
              echo 真实文件时长在真实文件的源文件时长上下5s之间 >> ${logfile}
              echo 查看真实文件的分辨率 >> ${logfile}
              realFileBitrate=`getBitrate ${realFile}`
              echo 真实文件的分辨率是 ${realFileBitrate} >> ${logfile}
              #如果真实文件的分辨率大于700(即此次的压缩标准),那么就应该压缩
              if [[ ${realFileBitrate} -ge ${dubboStandSign} ]];then
                echo 真实文件的分辨率大于此次的压缩标准 ${standSign}的2倍,需要把真实文件的源文件再压缩一次 >> ${logfile}
                echo "判断源文件的分辨率是否大于标准的2倍,如果大于,就压缩源文件;如果不大于就使用源文件.防止真实文件是越压越大的情况" >> ${logfile}
                
                realSourceFileBitrate=`getBitrate ${realSourceFile}` #获取真实文件源文件的分辨率
                if [[ ${realSourceFileBitrate} -ge ${dubboStandSign} ]];then
                  echo 真实文件源文件的分辨率是: ${realSourceFileBitrate}  >> ${logfile}
                  echo 真实文件源文件的分辨率大于此次压缩标准的2倍,可以压缩真实文件的源文件  >> ${logfile}
                  compressStatus=`compress ${realSourceFile}`
                  if [[ ${compressStatus}x = 0x ]];then #决定:替换软连接的目标文件
                    echo 替换软连接的目标文件 >> ${logfile}
                    extName=${realFile##*.}
                    #compressFile=`echo ${sourceFile}|sed "s/\.${extName}/_y${standSign}\.${extName}/g"` #***_y700.mp4
                    compressFile=${notExtNameSourceFileName}_y${standSign}.${extName} #tong_ming_ming_fa_.mp4.zi_jian_ji_001_y700.mp4
                    #replaceLnsTarget ${sourceFile} ${compressFile} #替换软连接的目标文件
                    echo /bin/ln -sf ${compressFile} ${sourceFile} >> ${logfile}
                    echo rm -f ${realFile} >> ${logfile}
                    /bin/ln -sf ${compressFile} ${sourceFile}
                    rm -f ${realFile}
                    echo 替换结果如下:   >> ${logfile}
                    /bin/ls -l ${notExtNameSourceFileName}*   >> ${logfile}
                    
                    #killSelf
                  else
                    echo 软连接在工作,大于此次压缩标准的文件在工作,此次压缩标准是 ${standSign} >> ${logfile}
                    echo 正在工作的文件的分辨率是 ${realFileBitrate} >> ${logfile}
                    echo 执行标准 ${standSign} 失败,继续使用 原 压缩 文件 >> ${logfile}
                    echo 继续下一个文件吧 >> ${logfile}
                  fi
                else #否则就是,真实文件源文件的分辨率小于标准的2倍,继续使用源文件更好
                  echo 真实文件源文件的分辨率小于标准的2倍,继续使用源文件更好 >> ${logfile}
                  echo 删除 软连接 rm -f ${sourceFile} >> ${logfile}
                  echo 删除 真实文件 rm -f ${realFile} >> ${logfile}
                  echo 还原老文件 mv ${realSourceFile} ${sourceFile}  >> ${logfile}
                  rm -f ${sourceFile}
                  rm -f ${realFile}
                  mv ${realSourceFile} ${sourceFile}
                  /bin/ls -l ${notExtNameSourceFileName}*   >> ${logfile}
                  #killSelf
                fi
                #killSelf
              else
                echo 真实文件的分辨率不大于此次的压缩标准 ${standSign}的2倍,继续使用这个压缩文件 >> ${logfile}
                echo 这个压缩文件的分辨率是 ${realFileBitrate} >> ${logfile}

              fi
            else
              echo -e "\033[34;31m真实文件时长不等于真实文件的源文件时长,必须删除,重新压缩\033[0m" >> ${logfile}
              echo 删除 软连接 rm -f ${sourceFile} >> ${logfile}
              echo 删除 真实文件 rm -f ${realFile} >> ${logfile}
              echo 还原老文件 mv ${realSourceFile} ${sourceFile}  >> ${logfile}
              rm -f ${sourceFile}
              rm -f ${realFile}
              mv ${realSourceFile} ${sourceFile}
              
              #还原完老文件,我希望把这个老文件在执行一次此次标准的压缩
              compressSourceFile ${sourceFile}
              #killSelf
            fi
            insertLinkIgnoreNameFile  ${sourceFile} #需要把这个文件放入到压缩标准的忽略列表中,下回就不检查这个软连接了
            #时长是否一致
            #时长一致,压缩文件分辨率小于此次压缩标准
            #时长一致,压缩文件分辨率大于此次压缩标准,判断是否压缩老文件
            #时长一致,压缩文件分辨率大于此次压缩标准,判断是否压缩老文件,压缩老文件
            #时长一致,压缩文件分辨率大于此次压缩标准,判断是否压缩老文件,压缩老文件,成功,不成功
            #时长一致,压缩文件分辨率大于此次压缩标准,判断是否压缩老文件,不压缩老文件,还原老文件
            #总之一句话,这个软连接处理完了,可以加入此次压缩标准的忽略列表中了
          else #如果不存在,****
            echo 真实文件的源文件 不存在 ${realSourceFile} >> ${logfile}
            echo 真实文件的源文件不存在,说明真实文件的源文件丢了,应该终止程序,查看为什么 >> ${logfile}
            echo 原始文件丢失 ${realSourceFile} >> ${lossFile}
            killSelf
          fi
          #killSelf
        else
          pass
          #echo endSign ${endSign} >> ${logfile}
          #echo endSignTarget ${endSignTarget} >> ${logfile}
        fi
      done
      #killSelf
      ############################################################################################################
      ############################################################################################################
      ############################################################################################################
  else
    #echo 源文件是物理文件 跳过 ll ${sourceFile}   >> ${logfile}
    #continue
    #pass
    #killSelf
    
    if [[ `grep ${sourceFile} ${ignoreNameFile}`x != ''x ]];then #查找结果不为空,说明这个文件应该被忽略
      echo 这个文件此前被加入过忽略列表,跳过检查 grep ${sourceFile} ${ignoreNameFile} >>  ${logfile}
      #killSelf
      continue
    fi
  
    
    echo '进入物理文件识别阶段'  >> ${logfile}
    #break
    #sourceFile=/mnt/lvm/4.0upload/xxpt/files/6/course/b4b73306-25c4-3406-bd8f-1cd2b6918570/resource/ti_gao_hun_ning_tu_kang_dong_xing_de_cuo_shi_.mp4
    echo 源文件不是软连接 ${sourceFile}  >> ${logfile}
    echo 源文件是真实文件 ${sourceFile}  >> ${logfile}
    #这个源文件可能从来没被压缩过,也可能被压缩过
    #所以查找原文件是否有压缩文件
    notExtName=${sourceFile%.*}
    extName=${sourceFile##*.}
    ##压缩文件数组
    #compress1=${notExtName}_y.${extName}
    #compress2=${notExtName}_y200.${extName}
    #compress3=${notExtName}_y700.${extName}
    #compresses=${compress1}+' '+${compress2}+' '+${compress3}
    #compressesArray=${compresses}
    
    compressFile=''
    for endSignTarget in `echo ${endSignTargets}`
    do
      compressName=${notExtName}_${endSignTarget}.${extName}
      
      if [[ -f ${compressName} ]];then #如果存在,那就说明有压缩文件
        compressFile=${compressName}
        #echo 本次对比的压缩文件名是 ${compressName}  >> ${logfile}
        break
      fi
    done
    echo 经过查验compressFile为 ${compressFile} >> ${logfile}
    
    #break
    if [[ ${compressFile} == '' ]];then #如果压缩文件为空,说明没有压缩文件
      echo 没有压缩文件,压缩原文件 >> ${logfile}
      
      compressSourceFile ${sourceFile}
      insertIgnoreName ${sourceFile}
      #break
    else
      echo 有压缩文件,对比时长一致 >> ${logfile}
      #killSelf
      compareResult=`compareTime  ${sourceFile} ${compressFile}`
      echo 对比时长一致的结果是 ${compareResult}  >> ${logfile}
      if [[ ${compareResult} -eq 1 ]];then
        echo '原文件跟压缩文件时间一致,强制使用'  >> ${logfile}
        forceUseCompressFile ${sourceFile} ${compressFile}
        insertIgnoreName ${sourceFile}
        #killSelf
      else
        echo '原文件跟压缩文件时间不一致,删除,重压'  >> ${logfile}
        #killSelf
        echo rm -f ${compressFile}  >> ${logfile}
        #break
        #killSelf
        rm -f ${compressFile}
        compressSourceFile ${sourceFile}
        insertIgnoreName ${sourceFile}
        #break
        #killSelf
      fi
    fi
    
    #killSelf
  fi
  #exit  
done

echo 经过了${i}次循环  >> ${logfile}

#这一次运行脚本的目的是: 20200617
#1.看看重置软连接地址时的操作是否合理
#2.看看新压缩的文件会占用多大的空间

#20200619
#新加了判断软连接的目标文件是否存在,如果不存在,就终止

#20200621
#你要考虑,当有_y.mp4压缩文件,而没有绑定软连接的情况该如何处理
#找到原文件
#    查看是不是软连接
#        是软连接
#            那它就有压缩文件
#        不是软连接
#            查看它有没有压缩文件
#                有就做软连接
#                    前提是:压缩文件命名正确.
#                    这一步我已经用"checkCompressMiss.sh",检查过了:结果是,全部压缩过的文件命名都正确
#                没有就压缩做软连接

#20200624
#不压缩,只查看理论压缩文件大小
#grep 理论压缩文件大小 compressAndForceUseLittleMp4Filev2.20200624|awk -F ' ' 'BEGIN{sum=0}{sum+=$2}END{print sum/1024}'
#517.704

#20200624_2
#!给全部操作文件的变量补上单引号
#遇到文件名中有特殊字符的,就跳过了,没处理

#20200624_3 
#对脚本中实际操作用户文件的行为进行全面通测
#关闭标志是
#20200624测试,关闭上一个测试内容
#打开标志是
#20200624测试,打开上一个测试内容

#20200630
#检测压缩文件名定义故障
#取消测试,把软连接的continue打开就行了
#################################################_y.mp4文件存在,为什么没删除?
#有多少是这样的?
#要修复这种情况,用哪个脚本 check_duoyufile.sh

#20200701
#加入压缩失败的过滤列表功能

#20200722
#今天视频源文件视频压缩完毕,开始测试软连接时长和清晰度问题
#防止真实文件是越压越大的情况
#将对比过得软连接文件纳入此次压缩标准的忽略列表中,下次在遇到同名的软连接,就不再查验它了

#20200730
#软连接处理完了,处理近一个月内的物理文件

#20200731
#开始检查济宁的文件

#20210311
#用在唐山身上了


